Developer CD Series 2000 November: Tool Chest/Dev.CD Nov 00 TC Disk 1.toast/Sample Code/Archive/Networking/Http Server/•Mac_Classes/TBackGroundApp.cp

Text File | 2000-09-28 | 8.9 KB | 273 lines | [TEXT/CWIE]

//    TBackGroundApp.cp -  Macintosh Background Application class object
//
// Apple Macintosh Developer Technical Support
// Written by:  Vinne Moscaritolo
//
//  Copyright (work in progress)  Apple Computer, Inc All rights reserved.
//
// You may incorporate this sample code into your applications without
// restriction, though the sample code has been provided "AS IS" and the
// responsibility for its operation is 100% yours.  However, what you are
// not permitted to do is to redistribute the source as "DSC Sample Code"
// after having made changes. If you're going to re-distribute the source,
// we require that you make it clear in the source that the code was
// descended from Apple Sample Code, but that you've made changes.
//

#include "TBackGroundApp.h"
#include "TMacException.h"

// Global Functions
pascal OSErr AEDispatcher(AppleEvent* in,  AppleEvent* out, long Command);

// ---------------------------------------------------------------------------
//     TBackGroundApp::fgApplication
// ---------------------------------------------------------------------------
//    pointer to BackGround App object
//
TBackGroundApp*  TBackGroundApp::fgApplication;


// ---------------------------------------------------------------------------
//     TBackGroundApp
// ---------------------------------------------------------------------------
//    Default Constructor

TBackGroundApp::TBackGroundApp()
{
    TBackGroundApp::fgApplication = this;

    this->SetState(TBackGroundApp::kSInit);                // set out first state
    fSleepTime =     kSleep_1_Sec;                        // default sleep value (ticks)

    this->InitializeMemory();                            // initialize memory
    this->InstallAEHandler();                            // install our AE handler
}


// ---------------------------------------------------------------------------
//     ~TBackGroundApp
// ---------------------------------------------------------------------------
//    Destructor

TBackGroundApp::~TBackGroundApp()
{
}

// ---------------------------------------------------------------------------
//     TBackGroundApp::InitializeMemory
// ---------------------------------------------------------------------------
// initialize memory
void TBackGroundApp::InitializeMemory()
{
    const unsigned long kStackIncrementSize =  (24 * 1024);

 // Increase the space allocated for the application stack by lowering the heap limit.
    SetApplLimit((Ptr) ((unsigned long) GetApplLimit() - kStackIncrementSize));
       ThrowIfOSErr( MemError() );
    MaxApplZone();
}

// ---------------------------------------------------------------------------
//     TBackGroundApp::InitializeToolbox
// ---------------------------------------------------------------------------
// initialize Required mac toolbox
void TBackGroundApp::InitializeToolbox()
{

// Intialize sections need to support Notification Manager
    InitGraf((Ptr) &qd.thePort);

// _DON'T_ flush disk-inserted or os events or you'll be sorry!
    ::FlushEvents(everyEvent - diskMask - osMask, 0);
}

// ---------------------------------------------------------------------------
//     TBackGroundApp::DoNextEvent
// ---------------------------------------------------------------------------
//     Handle incoming events


void TBackGroundApp::DoNextEvent()
{
    if (!::WaitNextEvent(everyEvent, &fEventRecord, fSleepTime, 0L))
        fEventRecord.what = nullEvent;            // security issue
}

// ---------------------------------------------------------------------------
//     TBackGroundApp::DoEventLoop
// ---------------------------------------------------------------------------
// event loop swith statement functio

void TBackGroundApp::DoEventLoop()
{
    this->DoNextEvent();                        // get the next event record

    switch (fEventRecord.what)
    {
        case nullEvent:                            // we got a periodic null event
            this->DoIdle();                        // call idle handler
            break;

        case kHighLevelEvent:
            this->DoHighLevelEvent();            // handle our high level events (as AEs)
            break;

        default:
            break;
    }
};

// ---------------------------------------------------------------------------
//     TBackGroundApp::DoIdle
// ---------------------------------------------------------------------------
// Handle idle time

void TBackGroundApp::DoIdle()
{
}


// ---------------------------------------------------------------------------
//     TBackGroundApp::DoHighLevelEvent
// ---------------------------------------------------------------------------
// Handle high level events.

void TBackGroundApp::DoHighLevelEvent()
{
    ::AEProcessAppleEvent(&fEventRecord);
}


// ---------------------------------------------------------------------------
//     TBackGroundApp::Start
// ---------------------------------------------------------------------------
// Start the application and let it run until we change the state to Quit.

void TBackGroundApp::Start()
{
    this->SetState(TBackGroundApp::kSRun);            // set TBackGroundApp to run state

    while (fState != TBackGroundApp::kSQuit)
        this->DoEventLoop();
    this->Quit();                                    // out from the state, we will quit
}

// ---------------------------------------------------------------------------
//     TBackGroundApp::Quit
// ---------------------------------------------------------------------------
// Quit the application, do any possible cleanup.
void TBackGroundApp::Quit()
{
}

// ---------------------------------------------------------------------------
//     TBackGroundApp::InstallAEHandler
// ---------------------------------------------------------------------------
// install Apple event handlers
void TBackGroundApp::InstallAEHandler()
{

    ThrowIfOSErr( ::AEInstallEventHandler( kCoreEventClass, kAEOpenApplication,
                    NewAEEventHandlerProc(AEDispatcher), kAppOpen, false));

    ThrowIfOSErr( ::AEInstallEventHandler( kCoreEventClass, kAEOpenDocuments,
                    NewAEEventHandlerProc(AEDispatcher), kAppOpenDocuments, false));

    ThrowIfOSErr( ::AEInstallEventHandler( kCoreEventClass, kAEPrintDocuments,
                    NewAEEventHandlerProc(AEDispatcher), kAppPrint, false));

    ThrowIfOSErr( ::AEInstallEventHandler( kCoreEventClass, kAEQuitApplication,
                    NewAEEventHandlerProc(AEDispatcher), kAppQuit, false));

}

// ---------------------------------------------------------------------------
//     TBackGroundApp::SetState
// ---------------------------------------------------------------------------
//    STATE CHANGE METHODS
void TBackGroundApp::SetState(TBackGroundApp::EState theState)
{
    fState = theState;
}

// ---------------------------------------------------------------------------
//     AEDispatcher
// ---------------------------------------------------------------------------
//    AppleEvent Dispatcher Wrapper

pascal OSErr AEDispatcher(AppleEvent* in,  AppleEvent* out, long Command)
{
    return TBackGroundApp::fgApplication->DispatchAppleEvents(in, out, Command);        // dispatch event back to the framework
}

// ---------------------------------------------------------------------------
//     TBackGroundApp::DispatchAppleEvents
// ---------------------------------------------------------------------------
// Dispatch to the right Handler based on the command in the AE (refCon).

OSErr TBackGroundApp::DispatchAppleEvents(AppleEvent* in, AppleEvent* out, long command)
{
    switch (command)
    {
        case kAppQuit:                            // a quit AE
            return HandleQuit(in, out, command);

        case kAppOpen:                            // a  new AE
            return HandleOpen(in, out, command);

        case kAppOpenDocuments:                    // an open document AE
            return HandleOpenDocuments(in, out, command);

        case kAppPrint:                            // a print AE
            return HandlePrint(in, out, command);

        default:                                                // hmm, something else then…
            ThrowMsg("Problem: We are dealing with an AE command that we have no handler for");
            break;
    }
    return errAEEventNotHandled;
}

// ---------------------------------------------------------------------------
//     TBackGroundApp::HandleQuit
// ---------------------------------------------------------------------------
// Our General Quit Handler. Set state to Quit and return.

OSErr TBackGroundApp::HandleQuit(AppleEvent*,AppleEvent*,long)
{
    this->SetState(TBackGroundApp::kSQuit);        // set state to Quit
    return noErr;                                // need to have this due to AEHandler prototype
}

// ---------------------------------------------------------------------------
//     TBackGroundApp::HandleOpen
// ---------------------------------------------------------------------------
// handle the open AE

OSErr TBackGroundApp::HandleOpen(AppleEvent*,AppleEvent*,long)
{
    return errAEEventNotHandled;
}

// ---------------------------------------------------------------------------
//     TBackGroundApp::HandleOpenDocuments
// ---------------------------------------------------------------------------
// handle the OpenDocuments AE

OSErr TBackGroundApp::HandleOpenDocuments(AppleEvent*,AppleEvent*,long)
{
    return errAEEventNotHandled;
}

// ---------------------------------------------------------------------------
//     TBackGroundApp::HandlePrint
// ---------------------------------------------------------------------------
// handle the Print AE

OSErr TBackGroundApp::HandlePrint(AppleEvent*,AppleEvent*,long)
{
    return errAEEventNotHandled;
}